Observing the Evolution of QUIC Implementations

The QUIC protocol combines features that were initially found inside the TCP, TLS and HTTP/2 protocols. The IETF is currently finalising a complete specification of this protocol. More than a dozen of independent implementations have been developed in parallel with these standardisation activities. We propose and implement a QUIC test suite that interacts with public QUIC servers to verify their conformance with key features of the IETF specification. Our measurements, gathered over a semester, provide a unique viewpoint on the evolution of a protocol and of its implementations. They highlight the arrival of new features and some regressions among the different implementations.Comment: 6 pages, 8 figure

TCPSnitch: Dissecting the Usage of the Socket API

Networked applications interact with the TCP/IP stack through the socket API. Over the years, various extensions have been added to this popular API. In this paper, we propose and implement the TCPSnitch software that tracks the interactions between Linux and Android applications and the TCP/IP stack. We collect a dataset containing the interactions produced by more than 120 different applications. Our analysis reveals that applications use a variety of API calls. On Android, many applications use various socket options even if the Java API does not expose them directly. TCPSnitch and the associated dataset are publicly available.Comment: See https://www.tcpsnitch.or

Flexible multipath transport protocols

Since its inception in the early 70’s, the Internet has expanded to interconnect billions of computers. The last decade has seen the rise of multi-connected devices, such as smartphones that can attach to both Wi-Fi and cellular networks. Endhosts can leverage this availability of multiple network paths in two major ways. First, they can aggregate the bandwidth of the available networks. Second, they can support seamless network handover when one of the network paths fails. Applications rely on transport protocols to carry data between endhosts. These applications can have various requirements. While simple bulk transfers want to complete as fast as possible, interactive applications (such as voice-activated ones) have strict latency constraints, especially under mobile conditions. Furthermore, the device user might enforce additional constraints, such as limiting the cellular usage on smartphone for both monetary and energy purposes. This thesis explores how multipath transport protocols can adapt to their serving use cases. First, we quantify the performance of the state-of-the-art Multipath TCP on smartphones by performing two measurement campaigns. Second, based on our previous findings, we tune Multipath TCP for the smartphone use case and evaluate it with real Android phones. Next, we focus on the emerging QUIC protocol, design two versions for its Multipath extensions and evaluate their benefits in various scenarios. Finally, we reconsider the architecture of transport protocols such as their operations can be finely customized on a per-connection basis thanks to the dynamic injection of plugins.(FSA - Sciences de l'ingénieur) -- UCL, 202

The Packet Number Space Debate in Multipath QUIC

With a standardization process that attracted much interest, QUIC can been seen as the next general-purpose transport protocol. Still, it does not provide true multipath support yet, missing some use cases that Multipath TCP can address. To fill that gap, the IETF recently adopted a multipath proposal merging all the proposed designs. While it focuses on its core components, there still remains one major design issue in the proposal: the amount of packet number spaces that should be used. This paper provides experimental results with two different Multipath QUIC implementations based on NS3 simulations to understand the impact of using one packet number space per path or a single packet number space for the whole connection. Our results shows that using one packet number space per path makes the Multipath QUIC connection more resilient to the receiver’s heuristics to acknowledge packets and detect duplicates

Multiflow QUIC: A Generic Multipath Transport Protocol

Transport protocols and their multipath variants used to assume that network paths are symmetric and bidirectional. Actually, it is frequent to observe network asymmetries (ADSL, satellite,...) and some network paths can flow packets in only one direction (e.g., due to a firewall,...). This paper proposes to consider the more generic notion of unidirectional flows. Based on them, we design and implement Multiflow QUIC, a variant of QUIC that is aware of network asymmetries to spread data over multiple network paths. Our evaluation shows that this more generic approach is beneficial in asymmetric cases while being equivalent to multipath approaches in symmetric ones

The Case for Protocol Plugins

Transport protocols such as TCP, SCTP or QUIC are supposedly extensible thanks to their flexible packet formats. However, implementations also need to be modified to support such extensions and changing those extensions remains difficult. Furthermore, it is difficult for an application to finely tune the underlying protocol to its needs. Our proposed protocol plugins address these two needs. A protocol plugin is a small executable code which can be dynamically plugged inside an implementation on a per-connection basis. We first propose a methodology to modify an existing implementation to support protocol plugins. We apply this methodology to two different QUIC implementations written in C and Go. We then demonstrate how servers can extend client stacks with protocol plugins that implement Tail Loss Probe, Explicit Congestion Notification, pacing rate and different acknowledgement strategies. We then discuss how protocols should leverage protocol plugins

Multipath Extension for QUIC

Multipath TCP has shown how a reliable transport protocol can efficiently use multiple paths for a given connection. We leverage the experience gained with Multipath TCP to propose simple extensions that enable QUIC to efficiently use multiple paths during the lifetime of a QUIC connection

Multipath TCP with real Smartphone applications

Multipath TCP is a new TCP extension that allows spreading data across several paths. Smartphone are multi-homed devices that can take advantage of such ability. Compared to regular TCP, Multipath TCP is able to keep connections alive across different networks. This work explores three measurement campaigns. The first one analyses how Multipath TCP reacts on smartphones relative to TCP with predefined scenarios on real applications and partial control of the environment. We propose and implement an automated measurement framework and observe that Multipath TCP works on smartphones without requiring any change on the application. With the default scheduler, quite long connections are balanced on both interfaces depending of their performance, but behaviour of short connections mainly depends on the initial interface. The second one extends our analysis to real users and compare the traffic with the one seen by a Multipath TCP server. We show the heterogeneity of the subflows and observe that most of the subflows created by smartphones are not used. Multipath TCP's reinjections are quite rare, but can happen in burst, particularly in mobility scenarios. The third one studies the performance of Multipath TCP with the streaming use case. We notice that Multipath TCP offers a better service than TCP to its handover mechanisms. However, the current behaviour of Multipath TCP is not always what smartphone users expect and we propose several possible improvements for the current implementation.Mémoire de master [120] : ingénieur civil en informatique, Université catholique de Louvain, 2015Mémoire de master [120] en sciences informatiques, Université catholique de Louvain, 201

Every Millisecond Counts: Tuning Multipath TCP for Interactive Applications on Smartphones

Multipath TCP enables smartphones to simultaneously use both WiFi and LTE to exchange data over a single connection. This provides bandwidth aggregation and more importantly reduces the handover delay when switching from one network to another. This is very important for delay sensitive applications such as the growing voice activated apps. In this paper, we explore different techniques to tune Multipath TCP for interactive applications. On smartphones, user experience is always a compromise between network performance and energy consumption or battery lifetime. We first explore the open-source Multipath TCP implementation in the Linux kernel. Our measurements indicate that Linux needs to better take energy consumption into account. We then propose, implement and evaluate MultiMob, a solution providing fast handover with low energy consumption for interactive applications. MultiMob relies on three principles. First, it delays the utilization of the LTE network. Second, it allows the mobile to inform the server of its currently preferred wireless network. Third, MultiMob extends the Multipath TCP handshake to enable immediate retransmissions to speedup handover. We implement MultiMob on Android 6 smartphones and evaluate its benefits by using both microbenchmarks and in the field measurements